package com.ruoyi.inventory.service.impl;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.ruoyi.inventory.mapper.TInvSessionMapper;
import com.ruoyi.inventory.mapper.TInvSessionItemMapper;
import com.ruoyi.inventory.domain.TInvSession;
import com.ruoyi.inventory.domain.TInvSessionItem;
import com.ruoyi.inventory.service.ITInvSessionService;
import com.ruoyi.inventory.service.ITWarehouseStockService;
import com.ruoyi.inventory.util.InventoryItemConverter;

/**
 * 盘点Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-09-24
 */
@Service
public class TInvSessionServiceImpl implements ITInvSessionService 
{
    @Autowired
    private TInvSessionMapper tInvSessionMapper;
    
    @Autowired
    private TInvSessionItemMapper tInvSessionItemMapper;
    
    @Autowired
    private InventoryItemConverter inventoryItemConverter;
    
    @Autowired
    private ITWarehouseStockService tWarehouseStockService;

    /**
     * 查询盘点
     * 
     * @param id 盘点主键
     * @return 盘点
     */
    @Override
    public TInvSession selectTInvSessionById(Long id)
    {
        return tInvSessionMapper.selectTInvSessionById(id);
    }

    /**
     * 根据盘点单号查询盘点
     * 
     * @param sessionNo 盘点单号
     * @return 盘点
     */
    @Override
    public TInvSession selectTInvSessionBySessionNo(String sessionNo)
    {
        TInvSession session = tInvSessionMapper.selectTInvSessionBySessionNo(sessionNo);
        if (session != null) {
            // 加载盘点明细并转换为DTO
            List<TInvSessionItem> items = tInvSessionItemMapper.selectTInvSessionItemListBySessionId(session.getId());
            session.setPartList(inventoryItemConverter.toDTOList(items));
        }
        return session;
    }

    /**
     * 查询盘点列表
     * 
     * @param tInvSession 盘点
     * @return 盘点
     */
    @Override
    public List<TInvSession> selectTInvSessionList(TInvSession tInvSession)
    {
        return tInvSessionMapper.selectTInvSessionList(tInvSession);
    }

    /**
     * 新增盘点
     * 
     * @param tInvSession 盘点
     * @return 结果
     */
    @Override
    public int insertTInvSession(TInvSession tInvSession)
    {
        // 插入盘点主表
        int result = tInvSessionMapper.insertTInvSession(tInvSession);
        
        // 如果有盘点明细，需要插入明细数据
        if (result > 0 && tInvSession.getPartList() != null && !tInvSession.getPartList().isEmpty()) {
            for (com.ruoyi.inventory.domain.dto.InventoryItemDTO item : tInvSession.getPartList()) {
                TInvSessionItem sessionItem = new TInvSessionItem();
                sessionItem.setSessionId(tInvSession.getId());
                sessionItem.setSessionNo(tInvSession.getSessionNo()); // 设置盘点单号
                sessionItem.setPartNo(item.getPartNo());
                sessionItem.setTheoreticalQty(item.getTheoreticalQty());
                sessionItem.setActualQty(item.getActualQty());
                sessionItem.setIsDelete(0); // 未删除
                
                // 计算差异数量
                if (item.getActualQty() != null && item.getTheoreticalQty() != null) {
                    java.math.BigDecimal diff = item.getActualQty().subtract(item.getTheoreticalQty());
                    sessionItem.setDiffQty(diff);
                }
                
                // 插入盘点明细
                tInvSessionItemMapper.insertTInvSessionItem(sessionItem);
            }
        }
        
        return result;
    }

    /**
     * 修改盘点
     * 
     * @param tInvSession 盘点
     * @return 结果
     */
    @Override
    public int updateTInvSession(TInvSession tInvSession)
    {
        return tInvSessionMapper.updateTInvSession(tInvSession);
    }

    /**
     * 批量删除盘点
     * 
     * @param ids 需要删除的盘点主键
     * @return 结果
     */
    @Override
    public int deleteTInvSessionByIds(Long[] ids)
    {
        return tInvSessionMapper.deleteTInvSessionByIds(ids);
    }

    /**
     * 根据盘点单号批量删除盘点
     * 
     * @param sessionNos 需要删除的盘点单号集合
     * @return 结果
     */
    @Override
    public int deleteTInvSessionBySessionNos(String[] sessionNos)
    {
        return tInvSessionMapper.deleteTInvSessionBySessionNos(sessionNos);
    }

    /**
     * 删除盘点信息
     * 
     * @param id 盘点主键
     * @return 结果
     */
    @Override
    public int deleteTInvSessionById(Long id)
    {
        return tInvSessionMapper.deleteTInvSessionById(id);
    }

    /**
     * 执行盘点
     * 
     * @param tInvSession 盘点信息
     * @return 结果
     */
    @Override
    @Transactional
    public int executeInventory(TInvSession tInvSession)
    {
        // 根据盘点单号查询现有的盘点信息
        TInvSession existingSession = tInvSessionMapper.selectTInvSessionBySessionNo(tInvSession.getSessionNo());
        if (existingSession == null) {
            throw new RuntimeException("未找到盘点单：" + tInvSession.getSessionNo());
        }
        
        // 设置ID，确保能正确更新
        tInvSession.setId(existingSession.getId());
        
        // 更新盘点状态为已完成
        tInvSession.setStatus("COMPLETED");
        
        // 更新盘点信息
        int result = tInvSessionMapper.updateTInvSession(tInvSession);
        
        // 如果有盘点明细，需要更新明细数据并调整库存
        if (tInvSession.getPartList() != null && !tInvSession.getPartList().isEmpty()) {
            // 查询现有的盘点明细
            List<TInvSessionItem> existingItems = tInvSessionItemMapper.selectTInvSessionItemListBySessionId(existingSession.getId());
            
            for (com.ruoyi.inventory.domain.dto.InventoryItemDTO item : tInvSession.getPartList()) {
                // 根据备件编号找到对应的明细记录
                TInvSessionItem existingItem = existingItems.stream()
                    .filter(e -> e.getPartNo().equals(item.getPartNo()))
                    .findFirst()
                    .orElse(null);
                
                if (existingItem != null) {
                    // 更新实盘数量
                    existingItem.setActualQty(item.getActualQty());
                    
                    // 计算差异数量
                    if (item.getActualQty() != null && existingItem.getTheoreticalQty() != null) {
                        java.math.BigDecimal diff = item.getActualQty().subtract(existingItem.getTheoreticalQty());
                        existingItem.setDiffQty(diff);
                        
                        // 如果有差异，需要调整库存
                        if (diff.compareTo(java.math.BigDecimal.ZERO) != 0) {
                            try {
                                // 调用库存服务调整库存
                                tWarehouseStockService.adjustStockByInventory(
                                    existingSession.getWarehouseCode(),
                                    item.getPartNo(),
                                    diff,
                                    "盘点调整-" + tInvSession.getSessionNo()
                                );
                            } catch (Exception e) {
                                throw new RuntimeException("调整库存失败：" + e.getMessage(), e);
                            }
                        }
                    }
                    
                    // 更新盘点明细
                    tInvSessionItemMapper.updateTInvSessionItem(existingItem);
                }
            }
        }
        
        return result;
    }
}